+Thu Jul 16 01:27:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c (gtk_widget_set_usize): handle negative values
+ similar to gtk_widget_set_uposition(). that is: -1=unspecified,
+ -2=leave untouched. changed the width/height field of GtkWidgetAuxInfo
+ to be gint16s rather than guint16s, since that's what the code expected
+ (for a long time actually).
+
+ * gtk/gtkviewport.c:
+ added support for object arguments: GtkViewport::shadow_type,
+ GtkViewport::vadjustment and GtkViewport::hadjustment.
+ (gtk_viewport_add): chain gtk_bin_add.
+
+ * gtk/gtkscrolledwindow.c:
+ added support for object argument: GtkScrolledWindow::hscrollbar_policy,
+ GtkScrolledWindow::vscrollbar_policy and GtkScrolledWindow::viewport.
+
+ * gtk/gtkadjustment.h:
+ * gtk/gtkadjustment.c:
+ * gtk/gtkctree.h:
+ * gtk/gtkclist.h:
+ * gtk/gtkctree.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkscrolledwindow.h:
+ * gtk/gtkscrolledwindow.c:
+ * gtk/gtkviewport.h:
+ * gtk/gtkviewport.c:
+ GtkType and macro fixups.
+
Thu Jul 16 01:10:02 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.h :
+Thu Jul 16 01:27:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c (gtk_widget_set_usize): handle negative values
+ similar to gtk_widget_set_uposition(). that is: -1=unspecified,
+ -2=leave untouched. changed the width/height field of GtkWidgetAuxInfo
+ to be gint16s rather than guint16s, since that's what the code expected
+ (for a long time actually).
+
+ * gtk/gtkviewport.c:
+ added support for object arguments: GtkViewport::shadow_type,
+ GtkViewport::vadjustment and GtkViewport::hadjustment.
+ (gtk_viewport_add): chain gtk_bin_add.
+
+ * gtk/gtkscrolledwindow.c:
+ added support for object argument: GtkScrolledWindow::hscrollbar_policy,
+ GtkScrolledWindow::vscrollbar_policy and GtkScrolledWindow::viewport.
+
+ * gtk/gtkadjustment.h:
+ * gtk/gtkadjustment.c:
+ * gtk/gtkctree.h:
+ * gtk/gtkclist.h:
+ * gtk/gtkctree.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkscrolledwindow.h:
+ * gtk/gtkscrolledwindow.c:
+ * gtk/gtkviewport.h:
+ * gtk/gtkviewport.c:
+ GtkType and macro fixups.
+
Thu Jul 16 01:10:02 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.h :
+Thu Jul 16 01:27:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c (gtk_widget_set_usize): handle negative values
+ similar to gtk_widget_set_uposition(). that is: -1=unspecified,
+ -2=leave untouched. changed the width/height field of GtkWidgetAuxInfo
+ to be gint16s rather than guint16s, since that's what the code expected
+ (for a long time actually).
+
+ * gtk/gtkviewport.c:
+ added support for object arguments: GtkViewport::shadow_type,
+ GtkViewport::vadjustment and GtkViewport::hadjustment.
+ (gtk_viewport_add): chain gtk_bin_add.
+
+ * gtk/gtkscrolledwindow.c:
+ added support for object argument: GtkScrolledWindow::hscrollbar_policy,
+ GtkScrolledWindow::vscrollbar_policy and GtkScrolledWindow::viewport.
+
+ * gtk/gtkadjustment.h:
+ * gtk/gtkadjustment.c:
+ * gtk/gtkctree.h:
+ * gtk/gtkclist.h:
+ * gtk/gtkctree.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkscrolledwindow.h:
+ * gtk/gtkscrolledwindow.c:
+ * gtk/gtkviewport.h:
+ * gtk/gtkviewport.c:
+ GtkType and macro fixups.
+
Thu Jul 16 01:10:02 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.h :
+Thu Jul 16 01:27:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c (gtk_widget_set_usize): handle negative values
+ similar to gtk_widget_set_uposition(). that is: -1=unspecified,
+ -2=leave untouched. changed the width/height field of GtkWidgetAuxInfo
+ to be gint16s rather than guint16s, since that's what the code expected
+ (for a long time actually).
+
+ * gtk/gtkviewport.c:
+ added support for object arguments: GtkViewport::shadow_type,
+ GtkViewport::vadjustment and GtkViewport::hadjustment.
+ (gtk_viewport_add): chain gtk_bin_add.
+
+ * gtk/gtkscrolledwindow.c:
+ added support for object argument: GtkScrolledWindow::hscrollbar_policy,
+ GtkScrolledWindow::vscrollbar_policy and GtkScrolledWindow::viewport.
+
+ * gtk/gtkadjustment.h:
+ * gtk/gtkadjustment.c:
+ * gtk/gtkctree.h:
+ * gtk/gtkclist.h:
+ * gtk/gtkctree.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkscrolledwindow.h:
+ * gtk/gtkscrolledwindow.c:
+ * gtk/gtkviewport.h:
+ * gtk/gtkviewport.c:
+ GtkType and macro fixups.
+
Thu Jul 16 01:10:02 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.h :
+Thu Jul 16 01:27:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c (gtk_widget_set_usize): handle negative values
+ similar to gtk_widget_set_uposition(). that is: -1=unspecified,
+ -2=leave untouched. changed the width/height field of GtkWidgetAuxInfo
+ to be gint16s rather than guint16s, since that's what the code expected
+ (for a long time actually).
+
+ * gtk/gtkviewport.c:
+ added support for object arguments: GtkViewport::shadow_type,
+ GtkViewport::vadjustment and GtkViewport::hadjustment.
+ (gtk_viewport_add): chain gtk_bin_add.
+
+ * gtk/gtkscrolledwindow.c:
+ added support for object argument: GtkScrolledWindow::hscrollbar_policy,
+ GtkScrolledWindow::vscrollbar_policy and GtkScrolledWindow::viewport.
+
+ * gtk/gtkadjustment.h:
+ * gtk/gtkadjustment.c:
+ * gtk/gtkctree.h:
+ * gtk/gtkclist.h:
+ * gtk/gtkctree.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkscrolledwindow.h:
+ * gtk/gtkscrolledwindow.c:
+ * gtk/gtkviewport.h:
+ * gtk/gtkviewport.c:
+ GtkType and macro fixups.
+
Thu Jul 16 01:10:02 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.h :
+Thu Jul 16 01:27:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c (gtk_widget_set_usize): handle negative values
+ similar to gtk_widget_set_uposition(). that is: -1=unspecified,
+ -2=leave untouched. changed the width/height field of GtkWidgetAuxInfo
+ to be gint16s rather than guint16s, since that's what the code expected
+ (for a long time actually).
+
+ * gtk/gtkviewport.c:
+ added support for object arguments: GtkViewport::shadow_type,
+ GtkViewport::vadjustment and GtkViewport::hadjustment.
+ (gtk_viewport_add): chain gtk_bin_add.
+
+ * gtk/gtkscrolledwindow.c:
+ added support for object argument: GtkScrolledWindow::hscrollbar_policy,
+ GtkScrolledWindow::vscrollbar_policy and GtkScrolledWindow::viewport.
+
+ * gtk/gtkadjustment.h:
+ * gtk/gtkadjustment.c:
+ * gtk/gtkctree.h:
+ * gtk/gtkclist.h:
+ * gtk/gtkctree.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkscrolledwindow.h:
+ * gtk/gtkscrolledwindow.c:
+ * gtk/gtkviewport.h:
+ * gtk/gtkviewport.c:
+ GtkType and macro fixups.
+
Thu Jul 16 01:10:02 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.h :
+Thu Jul 16 01:27:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c (gtk_widget_set_usize): handle negative values
+ similar to gtk_widget_set_uposition(). that is: -1=unspecified,
+ -2=leave untouched. changed the width/height field of GtkWidgetAuxInfo
+ to be gint16s rather than guint16s, since that's what the code expected
+ (for a long time actually).
+
+ * gtk/gtkviewport.c:
+ added support for object arguments: GtkViewport::shadow_type,
+ GtkViewport::vadjustment and GtkViewport::hadjustment.
+ (gtk_viewport_add): chain gtk_bin_add.
+
+ * gtk/gtkscrolledwindow.c:
+ added support for object argument: GtkScrolledWindow::hscrollbar_policy,
+ GtkScrolledWindow::vscrollbar_policy and GtkScrolledWindow::viewport.
+
+ * gtk/gtkadjustment.h:
+ * gtk/gtkadjustment.c:
+ * gtk/gtkctree.h:
+ * gtk/gtkclist.h:
+ * gtk/gtkctree.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkscrolledwindow.h:
+ * gtk/gtkscrolledwindow.c:
+ * gtk/gtkviewport.h:
+ * gtk/gtkviewport.c:
+ GtkType and macro fixups.
+
Thu Jul 16 01:10:02 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.h :
(tabbed GTK_CTREE_LINES_TABBED)
(none GTK_CTREE_LINES_NONE))
+(define-enum GtkCTreeExpansion
+ (expand GTK_CTREE_EXPANSION_EXPAND)
+ (expand-recursive GTK_CTREE_EXPANSION_EXPAND_RECURSIVE)
+ (collapse GTK_CTREE_EXPANSION_COLLAPSE)
+ (collapse-recursive GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE)
+ (toggle GTK_CTREE_EXPANSION_TOGGLE)
+ (toggle-recursive GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE))
+
; enumerations from "./gtkdebug.h"
(define-flags GtkDebugFlag
(color-context GDK_DEBUG_COLOR_CONTEXT)
(xim GDK_DEBUG_XIM))
+; enumerations from "../gdk/gdkrgb.h"
+
+(define-enum GdkRgbDither
+ (none GDK_RGB_DITHER_NONE)
+ (normal GDK_RGB_DITHER_NORMAL)
+ (max GDK_RGB_DITHER_MAX))
+
; enumerations from "../gdk/gdktypes.h"
(define-enum GdkWindowType
(GtkClassInitFunc) NULL,
};
- adjustment_type = gtk_type_unique (gtk_data_get_type (), &adjustment_info);
+ adjustment_type = gtk_type_unique (GTK_TYPE_DATA, &adjustment_info);
}
return adjustment_type;
#endif /* __cplusplus */
-#define GTK_ADJUSTMENT(obj) (GTK_CHECK_CAST (obj, gtk_adjustment_get_type (), GtkAdjustment))
-#define GTK_ADJUSTMENT_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, gtk_adjustment_get_type (), GtkAdjustmentClass))
-#define GTK_IS_ADJUSTMENT(obj) (GTK_CHECK_TYPE (obj, gtk_adjustment_get_type ()))
+#define GTK_TYPE_ADJUSTMENT (gtk_adjustment_get_type ())
+#define GTK_ADJUSTMENT(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_ADJUSTMENT, GtkAdjustment))
+#define GTK_ADJUSTMENT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_ADJUSTMENT, GtkAdjustmentClass))
+#define GTK_IS_ADJUSTMENT(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_ADJUSTMENT))
+#define GTK_IS_ADJUSTMENT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ADJUSTMENT))
typedef struct _GtkAdjustment GtkAdjustment;
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
(GtkClassInitFunc) NULL,
};
- clist_type = gtk_type_unique (gtk_container_get_type (), &clist_info);
+ clist_type = gtk_type_unique (GTK_TYPE_CONTAINER, &clist_info);
}
return clist_type;
widget_class = (GtkWidgetClass *) klass;
container_class = (GtkContainerClass *) klass;
- parent_class = gtk_type_class (gtk_container_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
clist_signals[SELECT_ROW] =
gtk_signal_new ("select_row",
g_return_val_if_fail (titles != NULL, NULL);
- widget = gtk_type_new (gtk_clist_get_type ());
+ widget = gtk_type_new (GTK_TYPE_CLIST);
gtk_clist_construct (GTK_CLIST (widget), columns, titles);
if (columns < 1)
return NULL;
- clist = gtk_type_new (gtk_clist_get_type ());
+ clist = gtk_type_new (GTK_TYPE_CLIST);
gtk_clist_construct (clist, columns, NULL);
return GTK_WIDGET (clist);
}
GTK_CELL_WIDGET
} GtkCellType;
-#define GTK_TYPE_CLIST (gtk_clist_get_type ())
-#define GTK_CLIST(obj) (GTK_CHECK_CAST ((obj), gtk_clist_get_type (), GtkCList))
-#define GTK_CLIST_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), gtk_clist_get_type (), GtkCListClass))
-#define GTK_IS_CLIST(obj) (GTK_CHECK_TYPE ((obj), gtk_clist_get_type ()))
-#define GTK_IS_CLIST_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CLIST))
-
-#define GTK_CLIST_FLAGS(clist) (GTK_CLIST (clist)->flags)
-#define GTK_CLIST_SET_FLAG(clist,flag) (GTK_CLIST_FLAGS (clist) |= (GTK_ ## flag))
-#define GTK_CLIST_UNSET_FLAG(clist,flag) (GTK_CLIST_FLAGS (clist) &= ~(GTK_ ## flag))
+#define GTK_TYPE_CLIST (gtk_clist_get_type ())
+#define GTK_CLIST(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_CLIST, GtkCList))
+#define GTK_CLIST_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CLIST, GtkCListClass))
+#define GTK_IS_CLIST(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_CLIST))
+#define GTK_IS_CLIST_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CLIST))
+
+#define GTK_CLIST_FLAGS(clist) (GTK_CLIST (clist)->flags)
+#define GTK_CLIST_SET_FLAG(clist,flag) (GTK_CLIST_FLAGS (clist) |= (GTK_ ## flag))
+#define GTK_CLIST_UNSET_FLAG(clist,flag) (GTK_CLIST_FLAGS (clist) &= ~(GTK_ ## flag))
#define GTK_CLIST_FROZEN(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_FROZEN)
#define GTK_CLIST_IN_DRAG(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_IN_DRAG)
(GtkClassInitFunc) NULL,
};
- ctree_type = gtk_type_unique (gtk_clist_get_type (), &ctree_info);
+ ctree_type = gtk_type_unique (GTK_TYPE_CLIST, &ctree_info);
}
return ctree_type;
container_class = (GtkContainerClass *) klass;
clist_class = (GtkCListClass *) klass;
- parent_class = gtk_type_class (gtk_clist_get_type ());
- container_class = gtk_type_class (gtk_container_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_CLIST);
+ container_class = gtk_type_class (GTK_TYPE_CONTAINER);
ctree_signals[TREE_SELECT_ROW] =
gtk_signal_new ("tree_select_row",
g_return_val_if_fail (columns > 0, NULL);
g_return_val_if_fail (tree_column >= 0 && tree_column < columns, NULL);
- widget = gtk_type_new (gtk_ctree_get_type ());
+ widget = gtk_type_new (GTK_TYPE_CTREE);
gtk_ctree_construct (GTK_CTREE (widget), columns, tree_column, titles);
return widget;
}
{
#endif /* __cplusplus */
-#define GTK_CTREE(obj) \
- (GTK_CHECK_CAST ((obj), gtk_ctree_get_type (), GtkCTree))
-#define GTK_CTREE_CLASS(klass) \
- (GTK_CHECK_CLASS_CAST ((klass), gtk_ctree_get_type (), GtkCTreeClass))
-#define GTK_IS_CTREE(obj) \
- (GTK_CHECK_TYPE ((obj), gtk_ctree_get_type ()))
+#define GTK_TYPE_CTREE (gtk_ctree_get_type ())
+#define GTK_CTREE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_CTREE, GtkCTree))
+#define GTK_CTREE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CTREE, GtkCTreeClass))
+#define GTK_IS_CTREE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_CTREE))
+#define GTK_IS_CTREE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CTREE))
+
#define GTK_CTREE_ROW(_glist_) ((GtkCTreeRow *)((_glist_)->data))
#define GTK_CTREE_TREE(_ctree_, _glist_) \
((GtkCellTree *) &(((GtkCTreeRow *)((_glist_)->data))->cell[(_ctree_)->tree_col]))
g_return_if_fail (arg_name != NULL);
g_return_if_fail (arg_type > GTK_TYPE_NONE);
g_return_if_fail (arg_id > 0);
- g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) != 0);
g_return_if_fail ((arg_flags & GTK_ARG_CHILD_ARG) == 0);
-
+ if (arg_flags & GTK_ARG_CONSTRUCT)
+ g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) == GTK_ARG_READWRITE);
+ else
+ g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) != 0);
+
if (!object_arg_info_ht)
object_arg_info_ht = g_hash_table_new (gtk_arg_info_hash,
gtk_arg_info_equal);
#define SCROLLBAR_SPACING(w) (GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT (w)->klass)->scrollbar_spacing)
+enum {
+ ARG_0,
+ ARG_VIEWPORT,
+ ARG_HSCROLLBAR_POLICY,
+ ARG_VSCROLLBAR_POLICY
+};
+
static void gtk_scrolled_window_class_init (GtkScrolledWindowClass *klass);
static void gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window);
+static void gtk_scrolled_window_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_scrolled_window_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_scrolled_window_destroy (GtkObject *object);
static void gtk_scrolled_window_finalize (GtkObject *object);
static void gtk_scrolled_window_map (GtkWidget *widget);
static GtkContainerClass *parent_class = NULL;
-guint
+GtkType
gtk_scrolled_window_get_type (void)
{
- static guint scrolled_window_type = 0;
+ static GtkType scrolled_window_type = 0;
if (!scrolled_window_type)
{
(GtkClassInitFunc) NULL,
};
- scrolled_window_type = gtk_type_unique (gtk_container_get_type (), &scrolled_window_info);
+ scrolled_window_type = gtk_type_unique (GTK_TYPE_CONTAINER, &scrolled_window_info);
}
return scrolled_window_type;
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
-
- parent_class = gtk_type_class (gtk_container_get_type ());
-
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
+
+ gtk_object_add_arg_type ("GtkScrolledWindow::viewport",
+ GTK_TYPE_VIEWPORT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_VIEWPORT);
+ gtk_object_add_arg_type ("GtkScrolledWindow::hscrollbar_policy",
+ GTK_TYPE_POLICY_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_HSCROLLBAR_POLICY);
+ gtk_object_add_arg_type ("GtkScrolledWindow::vscrollbar_policy",
+ GTK_TYPE_POLICY_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_VSCROLLBAR_POLICY);
+
+ object_class->set_arg = gtk_scrolled_window_set_arg;
+ object_class->get_arg = gtk_scrolled_window_get_arg;
object_class->destroy = gtk_scrolled_window_destroy;
object_class->finalize = gtk_scrolled_window_finalize;
class->scrollbar_spacing = 5;
}
+static void
+gtk_scrolled_window_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkScrolledWindow *scrolled_window;
+
+ scrolled_window = GTK_SCROLLED_WINDOW (object);
+
+ switch (arg_id)
+ {
+ GtkWidget *viewport;
+
+ case ARG_VIEWPORT:
+ g_return_if_fail (scrolled_window->viewport == NULL);
+ viewport = GTK_VALUE_POINTER (*arg);
+ if (!viewport)
+ viewport = gtk_viewport_new (NULL, NULL);
+ scrolled_window->viewport = viewport;
+ gtk_scrolled_window_construct (scrolled_window, NULL, NULL);
+ case ARG_HSCROLLBAR_POLICY:
+ gtk_scrolled_window_set_policy (scrolled_window,
+ GTK_VALUE_ENUM (*arg),
+ scrolled_window->vscrollbar_policy);
+ break;
+ case ARG_VSCROLLBAR_POLICY:
+ gtk_scrolled_window_set_policy (scrolled_window,
+ scrolled_window->hscrollbar_policy,
+ GTK_VALUE_ENUM (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_scrolled_window_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkScrolledWindow *scrolled_window;
+
+ scrolled_window = GTK_SCROLLED_WINDOW (object);
+
+ switch (arg_id)
+ {
+ case ARG_VIEWPORT:
+ GTK_VALUE_POINTER (*arg) = scrolled_window->viewport;
+ break;
+ case ARG_HSCROLLBAR_POLICY:
+ GTK_VALUE_ENUM (*arg) = scrolled_window->hscrollbar_policy;
+ break;
+ case ARG_VSCROLLBAR_POLICY:
+ GTK_VALUE_ENUM (*arg) = scrolled_window->vscrollbar_policy;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
{
{
GtkWidget *scrolled_window;
- scrolled_window = gtk_type_new (gtk_scrolled_window_get_type ());
+ scrolled_window = gtk_type_new (GTK_TYPE_SCROLLED_WINDOW);
gtk_scrolled_window_construct (GTK_SCROLLED_WINDOW (scrolled_window), hadjustment, vadjustment);
{
g_return_if_fail (scrolled_window != NULL);
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
- g_return_if_fail (scrolled_window->viewport == NULL);
+ g_return_if_fail (scrolled_window->hscrollbar == NULL);
+ g_return_if_fail (scrolled_window->vscrollbar == NULL);
+
+ if (scrolled_window->viewport)
+ g_return_if_fail (hadjustment == NULL && vadjustment == NULL);
+ else
+ scrolled_window->viewport = gtk_viewport_new (hadjustment, vadjustment);
- scrolled_window->viewport = gtk_viewport_new (hadjustment, vadjustment);
hadjustment = gtk_viewport_get_hadjustment (GTK_VIEWPORT (scrolled_window->viewport));
vadjustment = gtk_viewport_get_vadjustment (GTK_VIEWPORT (scrolled_window->viewport));
gtk_container_set_resize_mode (GTK_CONTAINER (scrolled_window->viewport), GTK_RESIZE_PARENT);
#endif /* __cplusplus */
-#define GTK_SCROLLED_WINDOW(obj) GTK_CHECK_CAST (obj, gtk_scrolled_window_get_type (), GtkScrolledWindow)
-#define GTK_SCROLLED_WINDOW_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_scrolled_window_get_type (), GtkScrolledWindowClass)
-#define GTK_IS_SCROLLED_WINDOW(obj) GTK_CHECK_TYPE (obj, gtk_scrolled_window_get_type ())
+#define GTK_TYPE_SCROLLED_WINDOW (gtk_scrolled_window_get_type ())
+#define GTK_SCROLLED_WINDOW(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindow))
+#define GTK_SCROLLED_WINDOW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindowClass))
+#define GTK_IS_SCROLLED_WINDOW(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_SCROLLED_WINDOW))
+#define GTK_IS_SCROLLED_WINDOW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLED_WINDOW))
typedef struct _GtkScrolledWindow GtkScrolledWindow;
};
-guint gtk_scrolled_window_get_type (void);
+GtkType gtk_scrolled_window_get_type (void);
GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
void gtk_scrolled_window_construct (GtkScrolledWindow *scrolled_window,
extern GtkType GTK_TYPE_CELL_TYPE;
extern GtkType GTK_TYPE_C_TREE_POS;
extern GtkType GTK_TYPE_C_TREE_LINE_STYLE;
+extern GtkType GTK_TYPE_C_TREE_EXPANSION;
extern GtkType GTK_TYPE_DEBUG_FLAG;
extern GtkType GTK_TYPE_ACCEL_FLAGS;
extern GtkType GTK_TYPE_ARROW_TYPE;
extern GtkType GTK_TYPE_FUNDAMENTAL_TYPE;
extern GtkType GTK_TYPE_WIDGET_FLAGS;
extern GtkType GTK_TYPE_GDK_DEBUG_FLAG;
+extern GtkType GTK_TYPE_GDK_RGB_DITHER;
extern GtkType GTK_TYPE_GDK_WINDOW_TYPE;
extern GtkType GTK_TYPE_GDK_WINDOW_CLASS;
extern GtkType GTK_TYPE_GDK_IMAGE_TYPE;
extern GtkType GTK_TYPE_GDK_EVENT;
extern GtkType GTK_TYPE_GDK_COLOR;
-#define GTK_TYPE_NUM_BUILTINS (100)
+#define GTK_TYPE_NUM_BUILTINS (102)
{ GTK_CTREE_LINES_NONE, "GTK_CTREE_LINES_NONE", "none" },
{ 0, NULL, NULL }
};
+static GtkEnumValue _gtk_c_tree_expansion_values[] = {
+ { GTK_CTREE_EXPANSION_EXPAND, "GTK_CTREE_EXPANSION_EXPAND", "expand" },
+ { GTK_CTREE_EXPANSION_EXPAND_RECURSIVE, "GTK_CTREE_EXPANSION_EXPAND_RECURSIVE", "expand-recursive" },
+ { GTK_CTREE_EXPANSION_COLLAPSE, "GTK_CTREE_EXPANSION_COLLAPSE", "collapse" },
+ { GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE, "GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE", "collapse-recursive" },
+ { GTK_CTREE_EXPANSION_TOGGLE, "GTK_CTREE_EXPANSION_TOGGLE", "toggle" },
+ { GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE, "GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE", "toggle-recursive" },
+ { 0, NULL, NULL }
+};
static GtkEnumValue _gtk_debug_flag_values[] = {
{ GTK_DEBUG_OBJECTS, "GTK_DEBUG_OBJECTS", "objects" },
{ GTK_DEBUG_MISC, "GTK_DEBUG_MISC", "misc" },
{ GDK_DEBUG_XIM, "GDK_DEBUG_XIM", "xim" },
{ 0, NULL, NULL }
};
+static GtkEnumValue _gdk_rgb_dither_values[] = {
+ { GDK_RGB_DITHER_NONE, "GDK_RGB_DITHER_NONE", "none" },
+ { GDK_RGB_DITHER_NORMAL, "GDK_RGB_DITHER_NORMAL", "normal" },
+ { GDK_RGB_DITHER_MAX, "GDK_RGB_DITHER_MAX", "max" },
+ { 0, NULL, NULL }
+};
static GtkEnumValue _gdk_window_type_values[] = {
{ GDK_WINDOW_ROOT, "GDK_WINDOW_ROOT", "root" },
{ GDK_WINDOW_TOPLEVEL, "GDK_WINDOW_TOPLEVEL", "toplevel" },
GTK_TYPE_ENUM, _gtk_c_tree_pos_values },
{ "GtkCTreeLineStyle", >K_TYPE_C_TREE_LINE_STYLE,
GTK_TYPE_ENUM, _gtk_c_tree_line_style_values },
+ { "GtkCTreeExpansion", >K_TYPE_C_TREE_EXPANSION,
+ GTK_TYPE_ENUM, _gtk_c_tree_expansion_values },
{ "GtkDebugFlag", >K_TYPE_DEBUG_FLAG,
GTK_TYPE_FLAGS, _gtk_debug_flag_values },
{ "GtkAccelFlags", >K_TYPE_ACCEL_FLAGS,
GTK_TYPE_FLAGS, _gtk_widget_flags_values },
{ "GdkDebugFlag", >K_TYPE_GDK_DEBUG_FLAG,
GTK_TYPE_FLAGS, _gdk_debug_flag_values },
+ { "GdkRgbDither", >K_TYPE_GDK_RGB_DITHER,
+ GTK_TYPE_ENUM, _gdk_rgb_dither_values },
{ "GdkWindowType", >K_TYPE_GDK_WINDOW_TYPE,
GTK_TYPE_ENUM, _gdk_window_type_values },
{ "GdkWindowClass", >K_TYPE_GDK_WINDOW_CLASS,
GtkType GTK_TYPE_CELL_TYPE = 0;
GtkType GTK_TYPE_C_TREE_POS = 0;
GtkType GTK_TYPE_C_TREE_LINE_STYLE = 0;
+GtkType GTK_TYPE_C_TREE_EXPANSION = 0;
GtkType GTK_TYPE_DEBUG_FLAG = 0;
GtkType GTK_TYPE_ACCEL_FLAGS = 0;
GtkType GTK_TYPE_ARROW_TYPE = 0;
GtkType GTK_TYPE_FUNDAMENTAL_TYPE = 0;
GtkType GTK_TYPE_WIDGET_FLAGS = 0;
GtkType GTK_TYPE_GDK_DEBUG_FLAG = 0;
+GtkType GTK_TYPE_GDK_RGB_DITHER = 0;
GtkType GTK_TYPE_GDK_WINDOW_TYPE = 0;
GtkType GTK_TYPE_GDK_WINDOW_CLASS = 0;
GtkType GTK_TYPE_GDK_IMAGE_TYPE = 0;
#include "gtksignal.h"
#include "gtkviewport.h"
+enum {
+ ARG_0,
+ ARG_HADJUSTMENT,
+ ARG_VADJUSTMENT,
+ ARG_SHADOW_TYPE
+};
+
+
static void gtk_viewport_class_init (GtkViewportClass *klass);
static void gtk_viewport_init (GtkViewport *viewport);
static void gtk_viewport_finalize (GtkObject *object);
+static void gtk_viewport_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_viewport_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_viewport_map (GtkWidget *widget);
static void gtk_viewport_unmap (GtkWidget *widget);
static void gtk_viewport_realize (GtkWidget *widget);
static GtkBinClass *parent_class;
-guint
+GtkType
gtk_viewport_get_type (void)
{
- static guint viewport_type = 0;
+ static GtkType viewport_type = 0;
if (!viewport_type)
{
(GtkClassInitFunc) NULL,
};
- viewport_type = gtk_type_unique (gtk_bin_get_type (), &viewport_info);
+ viewport_type = gtk_type_unique (GTK_TYPE_BIN, &viewport_info);
}
return viewport_type;
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
- parent_class = (GtkBinClass*) gtk_type_class (gtk_bin_get_type ());
-
+ parent_class = (GtkBinClass*) gtk_type_class (GTK_TYPE_BIN);
+
+ gtk_object_add_arg_type ("GtkViewport::hadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_HADJUSTMENT);
+ gtk_object_add_arg_type ("GtkViewport::vadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ ARG_VADJUSTMENT);
+ gtk_object_add_arg_type ("GtkViewport::shadow_type",
+ GTK_TYPE_SHADOW_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_SHADOW_TYPE);
+
+ object_class->set_arg = gtk_viewport_set_arg;
+ object_class->get_arg = gtk_viewport_get_arg;
object_class->finalize = gtk_viewport_finalize;
widget_class->map = gtk_viewport_map;
container_class->add = gtk_viewport_add;
}
+static void
+gtk_viewport_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkViewport *viewport;
+
+ viewport = GTK_VIEWPORT (object);
+
+ switch (arg_id)
+ {
+ GtkAdjustment *adjustment;
+
+ case ARG_HADJUSTMENT:
+ g_return_if_fail (viewport->hadjustment == NULL);
+ adjustment = GTK_VALUE_POINTER (*arg);
+ if (!adjustment)
+ adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+ gtk_viewport_set_hadjustment (viewport, adjustment);
+ break;
+ case ARG_VADJUSTMENT:
+ g_return_if_fail (viewport->vadjustment == NULL);
+ adjustment = GTK_VALUE_POINTER (*arg);
+ if (!adjustment)
+ adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+ gtk_viewport_set_vadjustment (viewport, adjustment);
+ break;
+ case ARG_SHADOW_TYPE:
+ gtk_viewport_set_shadow_type (viewport, GTK_VALUE_ENUM (*arg));
+ default:
+ break;
+ }
+}
+
+static void
+gtk_viewport_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkViewport *viewport;
+
+ viewport = GTK_VIEWPORT (object);
+
+ switch (arg_id)
+ {
+ case ARG_HADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = viewport->hadjustment;
+ break;
+ case ARG_VADJUSTMENT:
+ GTK_VALUE_POINTER (*arg) = viewport->vadjustment;
+ break;
+ case ARG_SHADOW_TYPE:
+ GTK_VALUE_ENUM (*arg) = viewport->shadow_type;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_viewport_init (GtkViewport *viewport)
{
gtk_object_sink (GTK_OBJECT (viewport->hadjustment));
gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
- (GtkSignalFunc) gtk_viewport_adjustment_changed,
- (gpointer) viewport);
+ gtk_viewport_adjustment_changed,
+ viewport);
gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
- (GtkSignalFunc)gtk_viewport_adjustment_value_changed,
- (gpointer) viewport);
+ gtk_viewport_adjustment_value_changed,
+ viewport);
- gtk_viewport_adjustment_changed (adjustment, (gpointer) viewport);
+ gtk_viewport_adjustment_changed (adjustment, viewport);
}
}
gtk_object_sink (GTK_OBJECT (viewport->vadjustment));
gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
- (GtkSignalFunc) gtk_viewport_adjustment_changed,
- (gpointer) viewport);
+ gtk_viewport_adjustment_changed,
+ viewport);
gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
- (GtkSignalFunc)gtk_viewport_adjustment_value_changed,
- (gpointer) viewport);
+ gtk_viewport_adjustment_value_changed,
+ viewport);
- gtk_viewport_adjustment_changed (adjustment, (gpointer) viewport);
+ gtk_viewport_adjustment_changed (adjustment, viewport);
}
}
static void
gtk_viewport_add (GtkContainer *container,
- GtkWidget *widget)
+ GtkWidget *child)
{
GtkBin *bin;
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_VIEWPORT (container));
- g_return_if_fail (widget != NULL);
+ g_return_if_fail (child != NULL);
bin = GTK_BIN (container);
+ g_return_if_fail (bin->child == NULL);
- if (!bin->child)
- {
- gtk_widget_set_parent (widget, GTK_WIDGET (container));
- gtk_widget_set_parent_window (widget, GTK_VIEWPORT (container)->bin_window);
- if (GTK_WIDGET_VISIBLE (widget))
- {
- if (GTK_WIDGET_MAPPED (widget->parent) &&
- !GTK_WIDGET_MAPPED (widget))
- gtk_widget_map (widget);
- }
-
- bin->child = widget;
+ gtk_widget_set_parent_window (child, GTK_VIEWPORT (bin)->bin_window);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (container))
- gtk_widget_queue_resize (widget);
- }
+ GTK_CONTAINER_CLASS (parent_class)->add (container, child);
}
static void
#endif /* __cplusplus */
-#define GTK_VIEWPORT(obj) GTK_CHECK_CAST (obj, gtk_viewport_get_type (), GtkViewport)
-#define GTK_VIEWPORT_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_viewport_get_type (), GtkViewportClass)
-#define GTK_IS_VIEWPORT(obj) GTK_CHECK_TYPE (obj, gtk_viewport_get_type ())
+#define GTK_TYPE_VIEWPORT (gtk_viewport_get_type ())
+#define GTK_VIEWPORT(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_VIEWPORT, GtkViewport))
+#define GTK_VIEWPORT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_VIEWPORT, GtkViewportClass))
+#define GTK_IS_VIEWPORT(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_VIEWPORT))
+#define GTK_IS_VIEWPORT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VIEWPORT))
typedef struct _GtkViewport GtkViewport;
{
GtkBin bin;
- gint shadow_type;
+ guint shadow_type;
GdkWindow *view_window;
GdkWindow *bin_window;
GtkAdjustment *hadjustment;
};
-guint gtk_viewport_get_type (void);
+GtkType gtk_viewport_get_type (void);
GtkWidget* gtk_viewport_new (GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
GtkAdjustment* gtk_viewport_get_hadjustment (GtkViewport *viewport);
gtk_widget_set_uposition (widget, -2, GTK_VALUE_INT (*arg));
break;
case ARG_WIDTH:
- gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -1);
+ gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -2);
break;
case ARG_HEIGHT:
- gtk_widget_set_usize (widget, -1, GTK_VALUE_INT (*arg));
+ gtk_widget_set_usize (widget, -2, GTK_VALUE_INT (*arg));
break;
case ARG_VISIBLE:
if (GTK_VALUE_BOOL(*arg))
gtk_object_set_data_by_id (GTK_OBJECT (widget), aux_info_key_id, aux_info);
}
- if (width > -1)
+ if (width > -2)
aux_info->width = width;
- if (height > -1)
+ if (height > -2)
aux_info->height = height;
if (GTK_WIDGET_VISIBLE (widget))
{
gint16 x;
gint16 y;
- guint16 width;
- guint16 height;
+ gint16 width;
+ gint16 height;
};
struct _GtkWidgetShapeInfo
projects / gtk4.git / commitdiff